package com.base.cn.platform.os.controller.book;

import com.base.cn.platform.os.common.constants.ConfigName;
import com.base.cn.platform.os.common.controller.BaseController;
import com.base.cn.platform.os.common.mybatis.Pagination;
import com.base.cn.platform.os.common.utils.ObjectUtils;
import com.base.cn.platform.os.common.utils.StringUtils;
import com.base.cn.platform.os.common.utils.result.ResultUtil;
import com.base.cn.platform.os.entity.book.Book;
import com.base.cn.platform.os.entity.book.BookCondition;
import com.base.cn.platform.os.entity.book.count.BookSumCount;
import com.base.cn.platform.os.service.book.BookBiz;
import com.base.cn.platform.os.service.manage.config.SysConfigService;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

/**
 * 图书Controller接口
 *
 * @author s.li
 * @create 2018-05-08-14:34
 */
@RestController
@RequestMapping("/course")
public class BookController extends BaseController {

    @Autowired
    private BookBiz bookBiz;
    @Autowired
    private SysConfigService sysConfigService;

    /**
     * 保存图书
     * @param book 图书实体对象
     * @return Map<String,Object>
     */
    @RequestMapping("/saveBook")
    public Map<String,Object> saveBook(@RequestBody Book book ){
        if(StringUtils.isEmpty(book.getBookName())){
            return ResultUtil.ERROR("请填写图书名称");
        }else{
            if(book.getBookName().trim().length()>50){
                return ResultUtil.ERROR("图书名称限制50个字以内");
            }
        }
        String message = StringUtils.checkSubjectCondition(book.getSubjectIds());
        if(StringUtils.isNotEmpty(message)){
            return ResultUtil.ERROR(message);
        }
        if(book.getRawPrice()==null){
            return ResultUtil.ERROR("请填写图书原价");
        }
        if(book.getRealPrice()==null){//如果图书的实销价为空
            book.setRealPrice(0D);
        }else{
            if(book.getRealPrice().doubleValue() > book.getRawPrice().doubleValue()){
                return ResultUtil.ERROR("实销价不能大于图书原价");
            }
        }
        //获取售卖方式
        TreeMap<String,String> saleContextMap = sysConfigService.getSysConfigContext(ConfigName.SALE);
        String selaSwitch = saleContextMap.get("selaSwitch");
        if("3".equals(selaSwitch)){//组合销售方式
            if(book.getMemberPrice()==null){//如果会员价格为空，则设置实售价为会员价
                book.setMemberPrice(0D);
            }else{
                if(book.getMemberPrice().doubleValue() > book.getRealPrice().doubleValue()){
                    return ResultUtil.ERROR("会员价不能大于实销价");
                }
            }
        }
        if(StringUtils.isEmpty(book.getAuthor())){
            return ResultUtil.ERROR("请填写图书作者");
        }else{
            if(book.getAuthor().trim().length()>10){
                return ResultUtil.ERROR("图书作者内容限制在10个字以内");
            }
        }
        if(StringUtils.isEmpty(book.getBookPress())){
            return ResultUtil.ERROR("请填写图书出版社");
        }else{
            if(book.getBookPress().trim().length()>30){
                return ResultUtil.ERROR("图书出版社限制在30个字以内");
            }
        }
        if(ObjectUtils.isEmpty(book.getPublishTime())){
            return ResultUtil.ERROR("请选择出版时间");
        }
        if(StringUtils.isEmpty(book.getImageJson())){
            return ResultUtil.ERROR("请上传图书封面");
        }
        if(StringUtils.isEmpty(book.getDepict())){
            return ResultUtil.ERROR("请填写图书简介");
        }
        book = bookBiz.saveBook(book);
        return ResultUtil.SUCCESS("图书保存成功",book);
    }

    /**
     * 通过ID，查询图书对象
     * @param id 图书ID
     * @param setSubjectData 是否设置专业数据
     * @param selectAllColumn 是否是查询所有的列表
     * @return 图书对象
     */
    @RequestMapping("/findBookById")
    public Book findBookById(@RequestParam("id") BigDecimal id,
                             @RequestParam("setSubjectData") boolean setSubjectData,
                             @RequestParam("selectAllColumn") boolean selectAllColumn){
        List<Book> bookList = this.findBookListByIds(id.toString(),setSubjectData,selectAllColumn);
        if(ObjectUtils.isNotEmpty(bookList)){
            return bookList.get(0);
        }
        return bookBiz.findBookById(id,setSubjectData,selectAllColumn);
    }

    /**
     * 通过ID串，查询图书列表
     * @param ids 图书ID串
     * @param setSubjectData 是否设置专业数据
     * @param selectAllColumn 是否是查询所有的列表
     * @return 图书Map
     */
    @RequestMapping("/findBookMapByIds")
    public Map<BigDecimal,Book> findBookMapByIds(@RequestParam("ids") String ids,
                                                 @RequestParam("setSubjectData") boolean setSubjectData,
                                                 @RequestParam("selectAllColumn") boolean selectAllColumn){
        return bookBiz.findBookMapByIds(ids,setSubjectData,selectAllColumn);
    }

    /**
     * 通过ID串，查询图书Map
     * @param condition 查询条件
     * @return 图书Map
     */
    @RequestMapping("/findBookMap")
    public Map<BigDecimal, Book> findBookMap(@RequestBody BookCondition condition){
        return bookBiz.findBookMapByIds(condition.getIds(),condition.isSubjectData(),condition.isSelectAllColumn());
    }

    /**
     * 通过ID串，查询图书列表
     * @param ids 图书ID串
     * @param setSubjectData 是否设置专业数据
     * @param selectAllColumn 是否是查询所有的列表
     * @return 图书列表
     */
    @RequestMapping("/findBookListByIds")
    public List<Book> findBookListByIds(@RequestParam("ids") String ids,
                                        @RequestParam("setSubjectData") boolean setSubjectData,
                                        @RequestParam("selectAllColumn") boolean selectAllColumn){
        return bookBiz.findBookListByIds(ids,setSubjectData,selectAllColumn);
    }

    /**
     * 多条件查询图书列表
     * @param condition 查询条件
     * @param setSubjectData 是否设置专业数据
     * @param selectAllColumn 是否是查询所有的列表
     * @return 图书列表
     */
    @RequestMapping("/findBookList")
    public List<Book> findBookList(@RequestBody BookCondition condition,
                                   @RequestParam("setSubjectData") boolean setSubjectData,
                                   @RequestParam("selectAllColumn") boolean selectAllColumn){
        return bookBiz.findBookList(condition,setSubjectData,selectAllColumn);
    }

    /**
     * 分页查询图书
     * @param condition 查询条件
     * @param currentPage 页码
     * @param pageSize 页面显示量
     * @param setSubjectData 是否设置专业数据
     * @param selectAllColumn 是否是查询所有的列表
     * @return 图书列表
     */
    @RequestMapping("/findWebBookPage")
    public PageInfo<Book> findWebBookPage(@RequestBody BookCondition condition,
                                       @RequestParam(value = "currentPage",required = false,defaultValue = "1") int currentPage,
                                       @RequestParam(value = "pageSize",required = false,defaultValue = "10") int pageSize,
                                       @RequestParam("setSubjectData") boolean setSubjectData,
                                       @RequestParam("selectAllColumn") boolean selectAllColumn){
        Pagination page = new Pagination();
        page.setCurrentPage(currentPage);
        page.setPageSize(pageSize);
        return bookBiz.findBookPage(condition,page,setSubjectData,selectAllColumn);
    }

    /**
     * 分页查询图书
     * @param condition 查询条件
     * @param currentPage 页码
     * @param setSubjectData 是否设置专业数据
     * @param selectAllColumn 是否是查询所有的列表
     * @return 图书列表
     */
    @RequestMapping("/findBookPage")
    public PageInfo<Book> findBookPage(@RequestBody BookCondition condition,
                                       @RequestParam(value = "currentPage",required = false,defaultValue = "1") int currentPage,
                                       @RequestParam("setSubjectData") boolean setSubjectData,
                                       @RequestParam("selectAllColumn") boolean selectAllColumn){
        Pagination page = new Pagination();
        page.setCurrentPage(currentPage);
        page.setPageSize(14);
        return bookBiz.findBookPage(condition,page,setSubjectData,selectAllColumn);
    }

    /**
     * 修改图书状态
     * @param ids 图书ID串
     * @param status 状态，0初始（可真删除），1上架，2下架，3删除
     * @return Map<String,Object>
     */
    @RequestMapping("/updateBookStatus")
    public Map<String,Object> updateBookStatus(@RequestParam("ids") String ids ,@RequestParam("status") int status){
        List<Book> bookList = bookBiz.findBookListByIds(ids,false,false);
        if(ObjectUtils.isNotEmpty(bookList)){
            Map<Integer,List<Book>> bookListMaps = bookList.stream().collect(Collectors.groupingBy(e->e.getStatus()));
            List<Book> bookList0 = bookListMaps.get(0);//初始状态
            List<Book> bookList1 = bookListMaps.get(1);//上架状态
            List<Book> bookList2 = bookListMaps.get(2);//下架状态
            List<BigDecimal> updateList = new ArrayList<>();
            List<BigDecimal> deleteList = new ArrayList<>();
            if(status == 1 || status ==3){//上架 、删除
                if(ObjectUtils.isNotEmpty(bookList0)){
                    bookList0.forEach(e->{
                        if(status==1){
                            updateList.add(e.getId());
                        }
                        if(status==3){
                            deleteList.add(e.getId());
                        }
                    });
                }
                if(ObjectUtils.isNotEmpty(bookList2)){
                    bookList2.forEach(e->{
                        updateList.add(e.getId());
                    });
                }
                if(ObjectUtils.isNotEmpty(bookList1)){
                    bookList1.forEach(e->{
                        updateList.add(e.getId());
                    });
                }
            }
            if(status ==2){//下架
                if(ObjectUtils.isNotEmpty(bookList1)){
                    bookList1.forEach(e->{
                        updateList.add(e.getId());
                    });
                }
            }
            bookBiz.updateBookStatus(updateList,deleteList,status);
        }
        return ResultUtil.SUCCESS("图书状态修改成功");
    }

    /**
     * 查询图书总数量数据
     * @return BookSumCount
     */
    @RequestMapping("/queryBookSumCount")
    public BookSumCount queryBookSumCount(){
        return bookBiz.queryBookSumCount();
    }

    /**
     * 修改图书库存
     * @param data
     * @return
     */
    @RequestMapping("/updateStockNum")
    public   Map updateStockNum(@RequestBody List<Map<String,Object>> data){
          bookBiz.updateStockNum(data);
        return ResultUtil.SUCCESS("图书库存修改成功");
    }

}
